//void volPointInterpolation::makeBoundaryWeights() const
//{
// const labelList& ptc = boundaryPoints();

// Calculate the correction vectors and weighting factors
//pointBoundaryWeightsPtr_ = new FieldField<Field, scalar>(ptc.size());
//FieldField<Field, scalar>& w = *pointBoundaryWeightsPtr_;
FieldField<Field, scalar> w(ptc.size());

{
  const labelListList& pf = mesh.pointFaces();

  const volVectorField& centres = mesh.C();

  const fvBoundaryMesh& bm = mesh.boundary();
  
  pointScalarField volPointSumWeights
    (
     IOobject
     (
      "volPointSumWeights",
      mesh.polyMesh::instance(),
      mesh
      ),
     pMesh,
     dimensionedScalar("zero", dimless, 0)
     );
  
  forAll (ptc, pointI)
    {
      const label curPoint = ptc[pointI];
      
      const labelList& curFaces = pf[curPoint];
      
      //w.hook(new scalarField(curFaces.size())); //philipc no hook function
      w.set
       (
	pointI,
	new scalarField(curFaces.size())
	);

      scalarField& curWeights = w[pointI];
      
      label nFacesAroundPoint = 0;
      
      const vector& pointLoc = mesh.points()[curPoint];
      
      // Go through all the faces
      forAll (curFaces, faceI)
	{
	  if (!mesh.isInternalFace(curFaces[faceI]))
	    {
	      // This is a boundary face.  If not in the empty patch
	      // or coupled calculate the extrapolation vector
	      label patchID =
		mesh.boundaryMesh().whichPatch(curFaces[faceI]);
	      
	      if
		(
		 !isA<emptyFvPatch>(bm[patchID])
		 && !(
		      bm[patchID].coupled()
		      //&& Pstream::parRun()
		      //&& !mesh.parallelData().cyclicParallel()
		      )
		 )
		{
		  curWeights[nFacesAroundPoint] =
		    1.0/mag
		    (
		     pointLoc
		     - centres.boundaryField()[patchID]
		     [
		      bm[patchID].patch().whichFace(curFaces[faceI])
		      ]
		     );
		  
		  nFacesAroundPoint++;
		}
	    }
	}
      
      // Reset the sizes of the local weights
      curWeights.setSize(nFacesAroundPoint);
      
      // Collect the sum of weights for parallel correction
      volPointSumWeights[curPoint] += sum(curWeights);
    }
  
  // Do parallel correction of weights
  
  // Update coupled boundaries
  // Work-around for cyclic parallels.  
  /*if (Pstream::parRun() && !mesh.parallelData().cyclicParallel())
    {
    forAll (volPointSumWeights.boundaryField(), patchI)
    {
    if (volPointSumWeights.boundaryField()[patchI].coupled())
    {
    volPointSumWeights.boundaryField()[patchI].initAddField();
    }
    }
    
    forAll (volPointSumWeights.boundaryField(), patchI)
    {
    if (volPointSumWeights.boundaryField()[patchI].coupled())
    {
    volPointSumWeights.boundaryField()[patchI].addField
    (
    volPointSumWeights.internalField()
    );
    }
    }
    }*/
  
  // Re-scale the weights for the current point
  forAll (ptc, pointI)
    {
      w[pointI] /= volPointSumWeights[ptc[pointI]];
    }
}
